{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from utils import *\n",
    "import tensorflow as tf\n",
    "from collections import Counter\n",
    "from sklearn.cross_validation import train_test_split\n",
    "import time\n",
    "from gensim import corpora, models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['negative', 'positive']\n",
      "10662\n",
      "10662\n"
     ]
    }
   ],
   "source": [
    "trainset = sklearn.datasets.load_files(container_path = 'data', encoding = 'UTF-8')\n",
    "trainset.data, trainset.target = separate_dataset(trainset,1.0)\n",
    "print(trainset.target_names)\n",
    "print(len(trainset.data))\n",
    "print(len(trainset.target))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1735 1735\n"
     ]
    }
   ],
   "source": [
    "labels, texts = [], []\n",
    "max_words = 15\n",
    "for no, i in enumerate(trainset.data):\n",
    "    if len(i.split()) > max_words:\n",
    "        labels.append(trainset.target[no])\n",
    "        texts.append(i)\n",
    "        \n",
    "trainset.data = texts\n",
    "trainset.target = labels\n",
    "print(len(trainset.data),len(trainset.target))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total words: 32091\n"
     ]
    }
   ],
   "source": [
    "texts = ' '.join(trainset.data)\n",
    "words = texts.split()\n",
    "word2freq = Counter(words)\n",
    "word_counts = [count for _, count in word2freq.most_common()]\n",
    "print(\"Total words:\", len(words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocabulary size: 10626\n"
     ]
    }
   ],
   "source": [
    "tokenized_docs = [(i, doc.split()) for i, doc in enumerate(trainset.data)]\n",
    "_words = set(words)\n",
    "word2idx = {c: i for i, c in enumerate(_words)}\n",
    "idx2word = {i: c for i, c in enumerate(_words)}\n",
    "vocab_size = len(idx2word)\n",
    "indexed = [word2idx[w] for w in words]\n",
    "encoded_docs = [(i, [word2idx[t] for t in doc]) for i, doc in tokenized_docs]\n",
    "print('Vocabulary size:', vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "doc_decoder = {i: doc_id for i, (doc_id, doc) in enumerate(encoded_docs)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_windows(doc,hws=5):\n",
    "    inside = [(w, doc[(i - hws):i] + doc[(i + 1):(i + hws + 1)]) for i, w in enumerate(doc[hws:-hws], hws)]\n",
    "    beginning = [(w, doc[:i] + doc[(i + 1):(2*hws + 1)]) for i, w in enumerate(doc[:hws], 0)]\n",
    "    end = [(w, doc[-(2*hws + 1):i] + doc[(i + 1):]) for i, w in enumerate(doc[-hws:], len(doc) - hws)]\n",
    "    return inside + beginning + end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(32091, 12)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = []\n",
    "for index, (_, doc) in enumerate(encoded_docs):\n",
    "    windows = get_windows(doc)\n",
    "    data += [[index, w[0]] + w[1] for w in windows]\n",
    "    \n",
    "data = np.array(data, dtype='int64')\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counts = np.array(word_counts)\n",
    "unigram_distribution = word_counts/sum(word_counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 27.1 s, sys: 16 ms, total: 27.1 s\n",
      "Wall time: 7.87 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "vocab_size = len(idx2word)\n",
    "embedding_dim = 50\n",
    "\n",
    "texts = [[str(j) for j in doc] for i, doc in encoded_docs]\n",
    "model = models.Word2Vec(texts, size=embedding_dim, min_count=1,window=5, workers=4, sg=1, negative=15, iter=70)\n",
    "model.init_sims(replace=True)\n",
    "\n",
    "word_vectors = np.zeros((vocab_size, embedding_dim)).astype('float32')\n",
    "for i in idx2word:\n",
    "    word_vectors[i] = model.wv[str(i)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "texts = [[idx2word[j] for j in doc] for i, doc in encoded_docs]\n",
    "dictionary = corpora.Dictionary(texts)\n",
    "corpus = [dictionary.doc2bow(text) for text in texts]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 17.4 s, sys: 4 ms, total: 17.4 s\n",
      "Wall time: 17.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "n_topics = 25\n",
    "lda = models.LdaModel(corpus, alpha=0.9, id2word=dictionary, num_topics=n_topics)\n",
    "corpus_lda = lda[corpus]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "topic 0 : film movie like one even make time enough story good\n",
      "topic 1 : one film movie like makes story us characters comedy much\n",
      "topic 2 : film movie like one story us makes even time characters\n",
      "topic 3 : film movie one like time story even movies make films\n",
      "topic 4 : film movie like one story us time good much makes\n",
      "topic 5 : movie film like story us one much films movies even\n",
      "topic 6 : film one movie like story way even much comedy director\n",
      "topic 7 : movie film like one even story good makes time director\n",
      "topic 8 : film movie like one much story way us films movies\n",
      "topic 9 : film movie like one make good story much even us\n",
      "topic 10 : like movie film one story make even films movies us\n",
      "topic 11 : film like movie one story even characters good films make\n",
      "topic 12 : film one movie like story us even characters much way\n",
      "topic 13 : film one movie like even make films makes much little\n",
      "topic 14 : film movie one like story much even never us films\n",
      "topic 15 : movie film like one even story films much time movies\n",
      "topic 16 : film movie one like story much way characters make director\n",
      "topic 17 : film one movie like even much time good might make\n",
      "topic 18 : like film movie one even story us time films little\n",
      "topic 19 : film movie like one characters time even story films us\n",
      "topic 20 : like film movie one story new little even time characters\n",
      "topic 21 : film movie like one films story even us may time\n",
      "topic 22 : film movie like one even life films time way us\n",
      "topic 23 : film movie like one us make story even much may\n",
      "topic 24 : film like movie story even may time new one director\n"
     ]
    }
   ],
   "source": [
    "for i, topics in lda.show_topics(n_topics, formatted=False):\n",
    "    print('topic', i, ':', ' '.join([t for t, _ in topics]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "doc_weights_init = np.zeros((len(corpus_lda), n_topics))\n",
    "for i in range(len(corpus_lda)):\n",
    "    topics = corpus_lda[i]\n",
    "    for j, prob in topics:\n",
    "        doc_weights_init[i, j] = prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "doc_weights_init = np.log(doc_weights_init + 1e-4)\n",
    "temperature = 7.0\n",
    "doc_weights_init /= temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "BETA = 0.75\n",
    "ETA = 0.4\n",
    "\n",
    "class Model:\n",
    "    def __init__(self, data,unigram_distribution, word_vectors,doc_weights_init,\n",
    "                 n_topics=25, batch_size=15, n_epochs=200,\n",
    "                 lambda_const=100.0, learning_rate = 1e-3,\n",
    "                 topics_weight_decay=1e-2,grad_clip=5.0):\n",
    "        \n",
    "        vocab_size, embedding_dim = word_vectors.shape\n",
    "        n_windows = len(data)\n",
    "        n_documents = len(np.unique(data[:, 0]))\n",
    "        \n",
    "        self.DOC_INDEX = tf.placeholder(tf.int32, shape=[None])\n",
    "        self.WORD_INDEX = tf.placeholder(tf.int32, shape=[None])\n",
    "        self.TARGET = tf.placeholder(tf.int32, shape=[None,data.shape[1]-2])\n",
    "\n",
    "        doc_ids = data[:, 0]\n",
    "        unique_docs, counts = np.unique(doc_ids, return_counts=True)\n",
    "        weights = np.zeros((len(unique_docs)), 'float32')\n",
    "        for i, j in enumerate(unique_docs):\n",
    "            weights[j] = 1.0/np.log(counts[i])\n",
    "        weights = tf.convert_to_tensor(weights, np.float32)\n",
    "        \n",
    "        unigram_distribution /= np.sum(unigram_distribution ** BETA)\n",
    "        unigram_distribution = tf.convert_to_tensor(unigram_distribution, np.float32)\n",
    "        \n",
    "        self.topic_vectors = tf.get_variable('topic_vectors',shape=(n_topics, embedding_dim),\n",
    "                        initializer=tf.orthogonal_initializer())\n",
    "        \n",
    "        alpha = 1.0/n_topics\n",
    "        self.embedding_doc = tf.convert_to_tensor(doc_weights_init, np.float32)\n",
    "        self.embedding_word = tf.convert_to_tensor(word_vectors, np.float32)\n",
    "        \n",
    "        embedded_doc = tf.nn.embedding_lookup(self.embedding_doc, self.DOC_INDEX)\n",
    "        embedded_word = tf.nn.embedding_lookup(self.embedding_word, self.WORD_INDEX)\n",
    "        doc_probs = tf.nn.softmax(embedded_doc)\n",
    "        unsqueezed_doc_probs = tf.expand_dims(doc_probs,2)\n",
    "        unsqueezed_topic_vectors = tf.expand_dims(self.topic_vectors,0)\n",
    "        doc_vectors = tf.reduce_sum(unsqueezed_doc_probs*unsqueezed_topic_vectors,1)\n",
    "        \n",
    "        w = tf.nn.embedding_lookup(weights, self.DOC_INDEX)\n",
    "        w /= tf.reduce_sum(w)\n",
    "        w *= batch_size\n",
    "        \n",
    "        dropout_doc = tf.nn.dropout(doc_vectors,0.5)\n",
    "        dropout_word = tf.nn.dropout(embedded_word,0.5)\n",
    "        context_vectors = dropout_doc + dropout_word\n",
    "        targets = tf.nn.embedding_lookup(self.embedding_word, self.TARGET)\n",
    "        \n",
    "        unsqueezed_context = tf.expand_dims(context_vectors,1)\n",
    "        log_targets = tf.log(tf.nn.sigmoid(tf.reduce_sum(targets*unsqueezed_context,2)))\n",
    "        noise = tf.multinomial([unigram_distribution],batch_size*(data.shape[1]-2)*batch_size)\n",
    "        noise = tf.reshape(noise, [batch_size, (data.shape[1]-2)*batch_size])\n",
    "        \n",
    "        noise = tf.nn.embedding_lookup(self.embedding_word, noise)\n",
    "        noise = tf.reshape(noise, [batch_size, data.shape[1]-2, batch_size, embedding_dim])\n",
    "        \n",
    "        unsqueezed_context = tf.expand_dims(tf.expand_dims(context_vectors,1),1)\n",
    "        \n",
    "        sum_log_sampled = tf.log(tf.nn.sigmoid(tf.negative(tf.reduce_sum(noise*unsqueezed_context, 3))))\n",
    "        sum_log_sampled = tf.reduce_sum(sum_log_sampled, 2)\n",
    "        \n",
    "        neg_loss = log_targets + sum_log_sampled\n",
    "        \n",
    "        self.negative_loss = tf.negative(tf.reduce_mean(w * tf.reduce_sum(neg_loss,1)))\n",
    "        self.dirichlet_loss = tf.reduce_mean(w * tf.reduce_sum(tf.nn.log_softmax(embedded_word),1))\n",
    "        self.dirichlet_loss *= lambda_const*(1.0 - alpha)\n",
    "        self.cost = self.negative_loss + self.dirichlet_loss\n",
    "        self.optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(self.cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "sess = tf.InteractiveSession()\n",
    "model = Model(data,unigram_distribution,word_vectors,doc_weights_init)\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1, avg loss -18743.395290\n",
      "epoch 2, avg loss -18777.047968\n",
      "epoch 3, avg loss -18783.673541\n",
      "epoch 4, avg loss -18786.040607\n",
      "epoch 5, avg loss -18787.099012\n",
      "epoch 6, avg loss -18787.629799\n",
      "epoch 7, avg loss -18787.927968\n",
      "epoch 8, avg loss -18788.118942\n",
      "epoch 9, avg loss -18788.218290\n",
      "epoch 10, avg loss -18788.354599\n"
     ]
    }
   ],
   "source": [
    "batch_size, epoch = 15, 10\n",
    "for i in range(epoch):\n",
    "    total_cost = 0\n",
    "    for k in range(0,(data.shape[0] // batch_size) * batch_size,batch_size):\n",
    "        batch_doc = data[k:k+batch_size,0]\n",
    "        batch_word = data[k:k+batch_size,1]\n",
    "        batch_target = data[k:k+batch_size,2:]\n",
    "        loss, _ = sess.run([model.cost, model.optimizer],feed_dict={model.DOC_INDEX:batch_doc,\n",
    "                                                                   model.WORD_INDEX:batch_word,\n",
    "                                                                   model.TARGET:batch_target})\n",
    "        total_cost += loss\n",
    "    total_cost /= (data.shape[0] // batch_size)\n",
    "    print('epoch %d, avg loss %f'%(i+1,total_cost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from MulticoreTSNE import MulticoreTSNE as TSNE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "doc_weights = model.embedding_doc.eval()\n",
    "topic_vectors = model.topic_vectors.eval()\n",
    "resulted_word_vectors = model.embedding_word.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(x):\n",
    "    e = np.exp(x)\n",
    "    n = np.sum(e, 1, keepdims=True)\n",
    "    return e/n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "topic_dist = softmax(doc_weights)\n",
    "doc_vecs = np.matmul(topic_dist, topic_vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "topic 1 : even may never make would story director us take way\n",
      "topic 2 : us even makes may would cast enjoy give actor performance\n",
      "topic 3 : story might best would us uses also thriller hes plot\n",
      "topic 4 : would never story time least cast rather made audience us\n",
      "topic 5 : even made way life may story time us take sense\n",
      "topic 6 : title films even us gets become never story may screen\n",
      "topic 7 : enough even us way would make gets really never hollywood\n",
      "topic 8 : way even movies best make might sense never sometimes enough\n",
      "topic 9 : may us even never much would hollywood make makes also\n",
      "topic 10 : makes make made real way us still time may even\n",
      "topic 11 : even little would make enough films time thriller might despite\n",
      "topic 12 : never enough made drama even films still fantasy sense obvious\n",
      "topic 13 : films makes sense make sometimes would story still also characters\n",
      "topic 14 : life never make us would audience though even watch notion\n",
      "topic 15 : us might may even much better title story would never\n",
      "topic 16 : may us left way make would plot enough even obvious\n",
      "topic 17 : may would even us might way life cast never time\n",
      "topic 18 : even story us make way would though cast life could\n",
      "topic 19 : even us story kind people would like best make way\n",
      "topic 20 : even us almost films cant made makes plot also way\n",
      "topic 21 : story make time enough us little never way picture action\n",
      "topic 22 : would us even never much enough make might makes could\n",
      "topic 23 : us way films even never time also story people something\n",
      "topic 24 : even make may said makes story enough performance entertainment time\n",
      "topic 25 : may little might movies much music even filmmakers makes way\n"
     ]
    }
   ],
   "source": [
    "similarity = np.matmul(topic_vectors, resulted_word_vectors.T)\n",
    "most_similar = similarity.argsort(axis=1)[:, -10:]\n",
    "\n",
    "for j in range(n_topics):\n",
    "    topic_words = ' '.join([idx2word[i] for i in reversed(most_similar[j])])\n",
    "    print('topic', j + 1, ':', topic_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "tsne = TSNE(perplexity=200, n_jobs=4)\n",
    "X = tsne.fit_transform(doc_vecs.astype('float64'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "unique_label = np.unique(trainset.target)\n",
    "encoded = LabelEncoder().fit_transform(trainset.target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9cbedd5e48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(16, 9))\n",
    "colors = ['red','blue']\n",
    "for no, i in enumerate(unique_label):\n",
    "    plt.scatter(X[encoded==i,0],X[encoded==i,1],label=unique_label[no],color=colors[no])\n",
    "plt.legend(['negative','positive'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
